﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//2.父子之间转换；
class BaseType
{
	virtual void func() {};
};
class ChildType :public BaseType
{
	virtual void func() {};
};
class Other {};

//1.静态转换，基础类型；
void testTypeConvert()
{
	//5.static_cast使用，static_cast<目标类型>(原始对象);

	char a = 'a';
	double d = static_cast<double>(a);
	cout << "d= " << d << endl;//d= 97

	BaseType* base = NULL;
	ChildType* child = NULL;

	//3.把BaseType转为ChildType*类型，向下转型，不安全；
	ChildType* child2 = static_cast<ChildType*>(base);

	//4.把ChildType转为BaseType*类型，向上转型，安全；
	BaseType* base2 = static_cast<BaseType*>(child);

	//6.转other类型，转换无效；非父子类型；
	//Other* other = static_cast<Other*>(base);


	//7.动态转换；基础类型不可以转换；
		//dynamic_cast非常严格，失去精度，或者不安全都不可以转换；
	//double d2 = dynamic_cast<double>(a);

	//8.把ChildType转为BaseType*类型，向上转型，安全；
	BaseType* base3 = dynamic_cast<BaseType*>(child);

	//9.把BaseType转为ChildType*类型，向下转型，不安全；
	//ChildType* child3 = dynamic_cast<ChildType*>(base);

	//10.dynamic_cast，如果发生了多态，那么可以让基类转为派生类，向下转型；
	BaseType* base4 = new ChildType;
	ChildType* child4 = dynamic_cast<ChildType*>(base4);

	//11.常量转换(const_cast)；
	const int* p = NULL;
	//12.去除const；
	int* newP = const_cast<int*>(p);

	int* p2 = NULL;
	const int* newP2 = const_cast<const int*>(p2);

	//13.不能对非指针或非引用的变量进行转换；
	const int  b = 10;
	//int b = const_cast<int>(b);

	//14.引用；
	int num = 20;
	int& numRef = num;
	const int& numRef2 = static_cast<const int&>(numRef);


	//15.重新解释转换(reinterpret_cast)；最不安全，不推荐，没什么用；
	int c = 10;
	int* pInt = reinterpret_cast<int*>(c);

	Other* other2 = reinterpret_cast<Other*>(base);
}

//main309：类型转换
int main309()
{
	testTypeConvert();

	system("pause");
	return EXIT_SUCCESS;
}